import 'package:flutter/foundation.dart';
import 'package:get/get.dart';
import 'storage_service.dart';
import '../api/index.dart';
import '../models/index.dart';
import '../values/constants.dart';

/// 用户服务 - 业务层服务
/// 
/// 🎯 核心职责：
/// - 用户登录/登出业务逻辑
/// - 用户信息管理和验证
/// - 用户权限控制
/// - 用户状态管理
/// - 用户数据持久化
class UserService extends GetxService {
  static UserService get to => Get.find<UserService>();
  
  // ==================== 依赖注入 ====================
  StorageService get _storageService => Get.find<StorageService>();
  
  // ==================== 响应式状态 ====================
  final _isLoggedIn = false.obs;
  final _currentUserProfile = Rxn<UserProfileModel>();
  final _userToken = ''.obs;
  final _refreshToken = ''.obs;
  
  // ==================== 同步访问器 ====================
  bool get isLoggedIn => _isLoggedIn.value;
  UserProfileModel? get currentUserProfile => _currentUserProfile.value;
  String get userToken => _userToken.value;
  String get refreshToken => _refreshToken.value;
  
  // ==================== 响应式访问器 ====================
  RxBool get isLoggedInRx => _isLoggedIn;
  Rxn<UserProfileModel> get currentUserProfileRx => _currentUserProfile;
  RxString get userTokenRx => _userToken;
  RxString get refreshTokenRx => _refreshToken;
  
  // ==================== 权限业务逻辑 ====================
  
  /// 检查用户是否有特定权限（核心业务逻辑）
  bool hasPermission(String permission) {
    final currentProfile = _currentUserProfile.value;
    if (currentProfile?.admin == true) return true;
    // TODO: 实现具体权限检查逻辑
    return false;
  }
  
  /// 检查用户是否有特定角色（核心业务逻辑）
  bool hasRole(String role) {
    final roles = _currentUserProfile.value?.roles?.map((r) => r.roleKey ?? '').toList() ?? [];
    return roles.contains(role);
  }
  
  // ==================== 生命周期 ====================
  @override
  Future<void> onInit() async {
    super.onInit();
    debugPrint('👤 UserService 初始化开始...');
    await _checkLoginStatus();
    debugPrint('✅ UserService 初始化完成');
  }
  
  @override
  void onClose() {
    debugPrint('🧹 UserService 正在清理...');
    super.onClose();
  }
  
  // ==================== 登录相关方法 ====================
  
  /// 用户登录
  Future<LoginResult> login({
    required String username,
    required String password,
  }) async {
    try {
      debugPrint('👤 开始用户登录: $username');
      
      final loginRequest = LoginReq(username: username, password: password);
      final apiResponse = await UserApi.login(loginRequest);
      
      if (!apiResponse.isSuccess || apiResponse.data == null) {
        final errorMessage = apiResponse.errorMessage.isNotEmpty 
            ? apiResponse.errorMessage 
            : '登录失败，请重试';
        debugPrint('❌ API登录失败: $errorMessage');
        return LoginResult.failure(errorMessage);
      }
      
      final tokenModel = apiResponse.data!;
      debugPrint('✅ API登录成功，获取到token');
      
      // 保存基础登录信息
      await _saveBasicLoginInfo(tokenModel, username);
      
      // ⚠️ Android原生项目不需要此步骤，登录接口已返回完整用户信息
      // await _fetchAndSaveUserProfile(tokenModel);
      
      debugPrint('✅ 用户登录成功: $username');
      return LoginResult.success();
      
    } catch (e) {
      debugPrint('❌ 用户登录异常: $e');
      return LoginResult.failure('登录过程中发生错误，请重试');
    }
  }
  
  /// Android原生登录（包含完整用户信息）
  /// 
  /// 对接Android原生项目的登录接口，返回完整用户信息
  /// [mobile] 手机号
  /// [password] 密码
  Future<LoginResult> loginNative({
    required String mobile,
    required String password,
  }) async {
    try {
      debugPrint('👤 开始Android原生登录: $mobile');
      
      // 创建包含设备信息的登录请求
      final loginRequest = await LoginReqNative.create(
        mobile: mobile,
        password: password,
      );
      
      debugPrint('📤 登录请求已创建');
      
      // 调用原生登录API
      final loginInfo = await UserApi.loginNative(loginRequest);
      
      debugPrint('✅ 原生API登录成功');
      debugPrint('========== 📊 完整登录响应数据 ==========');
      debugPrint('🔑 Token: ${loginInfo.userToken}');
      debugPrint('');
      debugPrint('👤 用户基本信息:');
      debugPrint('  - userId: ${loginInfo.userInfo.userId}');
      debugPrint('  - username: ${loginInfo.userInfo.username}');
      debugPrint('  - nickname: ${loginInfo.userInfo.nickname}');
      debugPrint('  - mobile: ${loginInfo.userInfo.mobile}');
      debugPrint('  - avatar: ${loginInfo.userInfo.avatar}');
      debugPrint('  - sex: ${loginInfo.userInfo.sex} (0:保密 1:男 2:女)');
      debugPrint('  - birthday: ${loginInfo.userInfo.birthday}');
      debugPrint('  - age: ${loginInfo.userInfo.age}');
      debugPrint('  - signature: ${loginInfo.userInfo.signature}');
      debugPrint('');
      debugPrint('📍 地理信息:');
      debugPrint('  - province: ${loginInfo.userInfo.province}');
      debugPrint('  - city: ${loginInfo.userInfo.city}');
      debugPrint('  - lat: ${loginInfo.userInfo.lat}');
      debugPrint('  - lng: ${loginInfo.userInfo.lng}');
      debugPrint('');
      debugPrint('⭐ 等级信息:');
      debugPrint('  - userGrade: ${loginInfo.userInfo.userGrade}');
      debugPrint('  - anchorGrade: ${loginInfo.userInfo.anchorGrade}');
      debugPrint('  - wealthGrade: ${loginInfo.userInfo.wealthGrade}');
      debugPrint('  - nobleGrade: ${loginInfo.userInfo.nobleGrade}');
      debugPrint('');
      debugPrint('💰 资产信息:');
      debugPrint('  - coin: ${loginInfo.userInfo.coin}');
      debugPrint('  - ticket: ${loginInfo.userInfo.ticket}');
      debugPrint('  - commission: ${loginInfo.userInfo.commission}');
      debugPrint('');
      debugPrint('📊 统计数据:');
      debugPrint('  - fansNum: ${loginInfo.userInfo.fansNum}');
      debugPrint('  - attentionNum: ${loginInfo.userInfo.attentionNum}');
      debugPrint('  - videoNum: ${loginInfo.userInfo.videoNum}');
      debugPrint('  - likeNum: ${loginInfo.userInfo.likeNum}');
      debugPrint('');
      debugPrint('🎯 状态信息:');
      debugPrint('  - isFirstLogin: ${loginInfo.isFirstLogin} (1:首次 2:非首次)');
      debugPrint('  - isLive: ${loginInfo.isLive} (1:不能开播 0:能开播)');
      debugPrint('  - isVideo: ${loginInfo.isVideo} (1:不能发布 0:能发布)');
      debugPrint('  - vipType: ${loginInfo.vipType} (0:非VIP 1:VIP)');
      debugPrint('  - isAnchor: ${loginInfo.userInfo.isAnchor} (0:非主播 1:主播)');
      debugPrint('  - isAuth: ${loginInfo.userInfo.isAuth}');
      debugPrint('');
      debugPrint('🎁 其他信息:');
      debugPrint('  - isFirstRecharge: ${loginInfo.isFirstRecharge}');
      debugPrint('  - followStatus: ${loginInfo.followStatus}');
      debugPrint('  - isPid: ${loginInfo.isPid}');
      debugPrint('  - packList: ${loginInfo.packList?.length ?? 0}个礼包');
      debugPrint('  - s2b2cConsumerToken: ${loginInfo.s2b2cConsumerToken}');
      debugPrint('  - roomId: ${loginInfo.userInfo.roomId}');
      debugPrint('  - liveStatus: ${loginInfo.userInfo.liveStatus}');
      debugPrint('==========================================');
      
      // 保存登录信息到本地
      await _saveNativeLoginInfo(loginInfo);
      
      debugPrint('✅ 原生登录成功: $mobile');
      return LoginResult.success();
      
    } catch (e) {
      debugPrint('❌ 原生登录异常: $e');
      return LoginResult.failure('登录过程中发生错误：$e');
    }
  }
  
  /// 获取短信验证码
  /// 
  /// [mobile] 手机号
  Future<bool> getSMSCode(String mobile) async {
    try {
      debugPrint('👤 开始获取验证码: $mobile');
      
      // 创建验证码请求
      final request = SmsCodeReq.forLogin(mobile);
      
      // 调用API获取验证码
      final result = await UserApi.getSMSCode(request);
      
      if (result) {
        debugPrint('✅ 验证码发送成功');
        return true;
      } else {
        debugPrint('❌ 验证码发送失败');
        return false;
      }
    } catch (e) {
      debugPrint('❌ 获取验证码异常: $e');
      return false;
    }
  }
  
  /// 验证码登录
  /// 
  /// [mobile] 手机号
  /// [code] 验证码
  Future<LoginResult> loginWithCode({
    required String mobile,
    required String code,
  }) async {
    try {
      debugPrint('👤 开始验证码登录: $mobile');
      
      // 创建包含设备信息的登录请求
      final loginRequest = await LoginReqNative.create(
        mobile: mobile,
        password: '', // 验证码登录不需要密码
      );
      
      // 创建验证码登录请求
      final phoneCodeRequest = PhoneCodeLoginReq(
        appVersion: loginRequest.appVersion,
        appVersionCode: loginRequest.appVersionCode,
        code: code,
        mobile: mobile,
        phoneFirm: loginRequest.phoneFirm,
        phoneModel: loginRequest.phoneModel,
        phoneUuid: loginRequest.phoneUuid,
        smsRegion: loginRequest.smsRegion,
      );
      
      debugPrint('📤 验证码登录请求已创建');
      
      // 调用验证码登录API
      final loginInfo = await UserApi.phoneCodeLogin(phoneCodeRequest);
      
      debugPrint('✅ 验证码登录成功');
      debugPrint('========== 📊 完整登录响应数据 ==========');
      debugPrint('🔑 Token: ${loginInfo.userToken}');
      debugPrint('👤 用户: ${loginInfo.userInfo.nickname ?? loginInfo.userInfo.username}');
      debugPrint('📱 手机号: ${loginInfo.userInfo.mobile}');
      debugPrint('==========================================');
      
      // 保存登录信息到本地
      await _saveNativeLoginInfo(loginInfo);
      
      debugPrint('✅ 验证码登录成功: $mobile');
      return LoginResult.success();
      
    } catch (e) {
      debugPrint('❌ 验证码登录异常: $e');
      return LoginResult.failure('登录过程中发生错误：$e');
    }
  }
  
  /// 用户退出登录
  Future<bool> logout() async {
    try {
      debugPrint('👤 用户退出登录');
      
      await _clearAllStorageData();
        _clearUserState();
        
        debugPrint('✅ 用户退出登录成功');
        return true;
      
    } catch (e) {
      debugPrint('❌ 用户退出登录失败: $e');
      return false;
    }
  }
  
  /// 刷新访问令牌
  Future<RefreshTokenResult> refreshAccessToken() async {
    try {
      debugPrint('🔄 UserService开始刷新访问令牌');
      
      final currentRefreshToken = _refreshToken.value;
      if (currentRefreshToken.isEmpty) {
        debugPrint('❌ 刷新令牌为空，无法刷新');
        return RefreshTokenResult.failure('刷新令牌不存在');
      }
      
      final apiResponse = await UserApi.refreshToken(currentRefreshToken);
      
      if (!apiResponse.isSuccess || apiResponse.data == null) {
        final errorMessage = apiResponse.errorMessage.isNotEmpty 
            ? apiResponse.errorMessage 
            : '刷新令牌失败，请重新登录';
        
        debugPrint('❌ API刷新令牌失败: $errorMessage');
        
        // 刷新失败可能是刷新令牌过期，自动退出登录
        if (apiResponse.code == Constants.httpStatusUnauthorized) {
          debugPrint('⚠️ 刷新令牌已过期，自动退出登录');
          await logout();
        }
        
        return RefreshTokenResult.failure(errorMessage);
      }
      
      final newTokenModel = apiResponse.data!;
      debugPrint('✅ 令牌刷新成功');
      
      // 更新本地令牌
      await _updateTokens(newTokenModel);
      
      return RefreshTokenResult.success(newTokenModel);
      
    } catch (e) {
      debugPrint('❌ 刷新令牌异常: $e');
      return RefreshTokenResult.failure('刷新令牌过程中发生错误');
    }
  }
  
  // ==================== 用户信息管理 ====================
  
  /// 获取我的页面头部信息
  /// 
  /// 包含粉丝数、关注数、互关数、打赏数等统计数据
  /// 对应Android原生的 /api/user/getMyHeadInfo 接口
  /// 
  /// [touid] 查看的用户ID，查看自己时传0
  /// 返回ApiUserInfoMyHead包含完整的我的页面数据
  Future<ApiUserInfoMyHead> getMyHeadInfo({int touid = 0}) async {
    try {
      debugPrint('👤 Service层：开始获取我的页面头部信息');
      
      // ✅ 检查登录状态（服务层职责）
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取我的页面头部信息');
        throw Exception('用户未登录，请先登录');
      }
      
      debugPrint('✅ 用户已登录，继续获取我的页面头部信息');
      
      // 调用 API 层获取头部信息
      final headInfo = await UserApi.getMyHeadInfo(touid: touid);
      debugPrint('✅ 从服务器获取我的页面头部信息成功');
      
      // ✅ Android原生API的getMyHeadInfo已包含完整用户信息，直接更新即可
      // 不需要再调用 /system/user/profile 接口（那是若依后台管理接口）
      if (touid == 0) {
        debugPrint('🔄 同步更新当前用户基本信息（从getMyHeadInfo数据）');
        
        // 将ApiUserInfo转换为UserProfileModel（更新部分字段）
        final currentProfile = _currentUserProfile.value;
        if (currentProfile != null) {
          final updatedProfile = UserProfileModel(
            userId: headInfo.userInfo.userId,
            userName: headInfo.userInfo.username ?? currentProfile.userName,
            nickName: headInfo.userInfo.nickname ?? currentProfile.nickName,
            avatar: headInfo.userInfo.avatar ?? currentProfile.avatar,
            sex: headInfo.userInfo.sex.toString(),
            phonenumber: headInfo.userInfo.mobile,
            // 保留其他字段
            email: currentProfile.email,
            status: currentProfile.status,
            delFlag: currentProfile.delFlag,
            loginIp: currentProfile.loginIp,
            loginDate: currentProfile.loginDate,
            createBy: currentProfile.createBy,
            createTime: currentProfile.createTime,
            updateBy: currentProfile.updateBy,
            updateTime: currentProfile.updateTime,
            remark: currentProfile.remark,
            dept: currentProfile.dept,
            roles: currentProfile.roles,
            roleIds: currentProfile.roleIds,
            postIds: currentProfile.postIds,
            roleId: currentProfile.roleId,
            admin: currentProfile.admin,
          );
          
          // ⚠️ 直接更新响应式状态和本地存储，不调用setUserProfile（避免触发额外API调用）
          _currentUserProfile.value = updatedProfile;
          await _saveUserProfileToStorage(updatedProfile);
          debugPrint('✅ 用户基本信息已从getMyHeadInfo同步更新');
        }
      }
      
      debugPrint('✅ Service层：我的页面头部信息获取完成');
      return headInfo;
      
    } catch (e) {
      debugPrint('❌ Service层：获取我的页面头部信息异常: $e');
      rethrow; // 重新抛出异常，让调用者处理
    }
  }
  
  /// ⚠️ 已重构 - Android原生项目适配
  /// 
  /// Android原生项目不使用若依框架的 /system/user/profile 接口
  /// 用户信息已在登录时获取（loginNative），并保存在本地缓存
  /// 各页面需要最新数据时，调用对应的Android原生API（如getMyHeadInfo）
  /// 
  /// 本方法现在只从本地缓存获取用户信息
  Future<UserProfileModel> getUserProfile() async {
    try {
      debugPrint('👤 获取本地缓存的用户信息');
      
      // ✅ 首先检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法获取用户信息');
        throw Exception('用户未登录，请先登录');
      }
      
      // 从本地缓存获取
      final userProfile = _currentUserProfile.value;
      if (userProfile != null) {
        debugPrint('✅ 从本地缓存获取用户信息成功: ${userProfile.nickName}');
        return userProfile;
      } else {
        debugPrint('❌ 本地缓存为空');
        throw Exception('本地用户信息缺失，请重新登录');
      }
      
    } catch (e) {
      debugPrint('❌ 获取用户信息失败: $e');
      rethrow;
    }
  }
  
  /// 设置用户信息（核心方法）
  Future<bool> setUserProfile(UserProfileModel userProfile) async {
    try {
      debugPrint('👤 设置用户信息: ${userProfile.nickName}');
      
      // 更新响应式状态
      _currentUserProfile.value = userProfile;
      
      // 保存到本地存储
      await _saveUserProfileToStorage(userProfile);
      
      debugPrint('✅ 用户信息设置成功');
      return true;
        
      } catch (e) {
      debugPrint('❌ 设置用户信息失败: $e');
      return false;
    }
  }
  
  /// ⚠️ 已废弃 - 若依框架接口，Android原生项目不使用
  /// 
  /// Android原生项目需要调用对应的原生API接口来上传头像
  /// @deprecated 等待Android原生API接口文档
  /*
  Future<AvatarUploadResult> uploadAndUpdateAvatar(String avatarFilePath) async {
    try {
      debugPrint('👤 Service层：开始上传并更新用户头像');
      
      // ✅ 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法上传头像');
        return AvatarUploadResult.failure('用户未登录，请先登录');
      }
      
      // 1️⃣ 调用API上传头像
      debugPrint('📤 步骤1: 调用API上传头像文件');
      final uploadResult = await UserApi.uploadAvatar(avatarFilePath);
      
      if (!uploadResult.success || uploadResult.imgUrl == null) {
        debugPrint('❌ 头像上传失败: ${uploadResult.errorMessage}');
        return uploadResult;
      }
      
      debugPrint('✅ 头像上传成功，获得URL: ${uploadResult.imgUrl}');
      
      // 2️⃣ 调用API更新用户信息（更新头像字段）
      debugPrint('📝 步骤2: 调用API更新用户头像信息');
      final request = UpdateUserProfileReq(avatar: uploadResult.imgUrl);
      final updatedProfile = await UserApi.updateUserProfile(request);
      
      debugPrint('✅ API返回更新后的用户信息: ${updatedProfile.nickName}');
      
      // 3️⃣ 更新Service状态（自动触发所有订阅者更新）
      debugPrint('🔄 步骤3: 更新Service响应式状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service层：头像上传和更新完成');
      debugPrint('🎉 所有监听此Service的页面将自动同步更新');
      
      return AvatarUploadResult.success(uploadResult.imgUrl!);
      
    } catch (e) {
      debugPrint('❌ Service层：上传头像异常: $e');
      return AvatarUploadResult.failure('头像上传异常：${e.toString()}');
    }
  }
  */
  
  /// ⚠️ 已废弃 - 若依框架接口，Android原生项目不使用
  /// 
  /// Android原生项目需要调用对应的原生API接口来更新用户信息
  /// @deprecated 等待Android原生API接口文档
  /*
  /// 批量更新用户信息（企业级架构标准化）
  /// 
  /// 🎯 按照6.2规范：批量保存策略
  /// - 用户编辑 → 暂存本地 → 点击保存 → 批量上传 → 批量更新Service
  /// - Service层统一管理API调用和状态同步
  /// 
  /// [request] 用户信息更新请求
  /// 返回更新后的用户信息模型，自动保存到本地
  Future<UserProfileModel> updateUserProfile(UpdateUserProfileReq request) async {
    try {
      debugPrint('👤 Service层：开始批量更新用户信息');
      debugPrint('📝 更新请求: ${request.toJson()}');
      
      // ✅ 检查登录状态
      if (!isLoggedIn) {
        debugPrint('❌ 用户未登录，无法更新用户信息');
        throw Exception('用户未登录，请先登录');
      }
      
      // 1️⃣ 调用API更新用户信息
      debugPrint('📤 步骤1: 调用API批量更新用户信息');
      final updatedProfile = await UserApi.updateUserProfile(request);
      
      debugPrint('✅ API返回更新后的用户信息: ${updatedProfile.nickName}');
      
      // 2️⃣ 更新Service状态（自动触发所有订阅者更新）
      debugPrint('🔄 步骤2: 更新Service响应式状态');
      await setUserProfile(updatedProfile);
      
      debugPrint('✅ Service层：用户信息批量更新完成');
      debugPrint('🎉 所有监听此Service的页面将自动同步更新');
      
      return updatedProfile;
      
    } catch (e) {
      debugPrint('❌ Service层：更新用户信息异常: $e');
      rethrow; // 重新抛出异常，让调用者处理
    }
  }
  */
  
  // ==================== 数据获取方法 ====================
  

  
  /// 获取最后登录时间
  DateTime? getLastLoginTime() {
    try {
      final timeString = _storageService.getString(Constants.storageKeyLastLoginTime);
      return timeString != null ? DateTime.parse(timeString) : null;
    } catch (e) {
      debugPrint('❌ 获取最后登录时间失败: $e');
      return null;
    }
  }
  
  /// 获取完整的TokenModel
  TokenModel? getTokenModel() {
    try {
      final tokenData = _storageService.getObject(Constants.storageKeyTokenModel);
      return tokenData != null ? TokenModel.fromJson(tokenData) : null;
    } catch (e) {
      debugPrint('❌ 获取TokenModel失败: $e');
      return null;
    }
  }
  
  // ==================== 私有方法 ====================
  
  /// 检查登录状态
  Future<void> _checkLoginStatus() async {
    try {
      final token = _storageService.getString(Constants.storageKeyUserToken) ?? '';
      final refreshToken = _storageService.getString(Constants.storageKeyRefreshToken) ?? '';
      final userProfileData = _storageService.getObject(Constants.storageKeyUserInfo);
      
      if (token.isNotEmpty && userProfileData != null) {
        debugPrint('👤 发现已保存的登录信息');
        
        final userProfile = UserProfileModel.fromJson(userProfileData);
        
        _userToken.value = token;
        _refreshToken.value = refreshToken;
        _currentUserProfile.value = userProfile;
        _isLoggedIn.value = true;
        
        // 检查登录是否过期
        await _checkLoginExpiration();
      } else {
        debugPrint('👤 未找到登录信息');
        _clearUserState();
      }
      
    } catch (e) {
      debugPrint('❌ 检查登录状态失败: $e');
      _clearUserState();
    }
  }
  
  /// 检查登录过期
  Future<void> _checkLoginExpiration() async {
    try {
      final lastLoginTime = getLastLoginTime();
      if (lastLoginTime != null) {
        final daysSinceLogin = DateTime.now().difference(lastLoginTime).inDays;
        if (daysSinceLogin > Constants.loginExpirationDays) {
          debugPrint('⚠️ 登录信息已过期，自动退出登录');
          await logout();
        }
      }
    } catch (e) {
      debugPrint('❌ 检查登录过期失败: $e');
    }
  }
  
  /// 清除用户状态
  void _clearUserState() {
    _isLoggedIn.value = false;
    _currentUserProfile.value = null;
    _userToken.value = '';
    _refreshToken.value = '';
  }
  
  /// 保存基础登录信息
  Future<void> _saveBasicLoginInfo(TokenModel tokenModel, String username) async {
    _userToken.value = tokenModel.accessToken;
    _refreshToken.value = tokenModel.refreshToken;
    _isLoggedIn.value = true;
    
    // 创建基础用户信息
    final basicProfile = UserProfileModel(
      userId: 0,
      userName: username,
      nickName: username,
    );
    _currentUserProfile.value = basicProfile;
    
    // 保存到存储
    await _storageService.setString(Constants.storageKeyUserToken, tokenModel.accessToken);
    await _storageService.setString(Constants.storageKeyRefreshToken, tokenModel.refreshToken);
    await _storageService.setString(Constants.storageKeyUsername, username);
    await _storageService.setString(Constants.storageKeyLastLoginTime, DateTime.now().toIso8601String());
    await _storageService.setObject(Constants.storageKeyTokenModel, tokenModel.toJson());
    
    debugPrint('✅ 基础登录信息保存成功');
  }
  
  /// 保存原生登录信息（Android原生登录专用）
  Future<void> _saveNativeLoginInfo(ApiUserInfoLogin loginInfo) async {
    try {
      debugPrint('💾 开始保存原生登录信息');
      
      // 保存Token
      _userToken.value = loginInfo.userToken;
      _refreshToken.value = loginInfo.userToken; // 原生API没有分离的refreshToken
      _isLoggedIn.value = true;
      
      // 将ApiUserInfo转换为UserProfileModel
      final userProfile = UserProfileModel(
        userId: loginInfo.userInfo.userId,
        userName: loginInfo.userInfo.username ?? '',
        nickName: loginInfo.userInfo.nickname ?? loginInfo.userInfo.username ?? '',
        // 可以根据需要添加更多字段映射
      );
      _currentUserProfile.value = userProfile;
      
      // 保存到本地存储
      await _storageService.setString(Constants.storageKeyUserToken, loginInfo.userToken);
      await _storageService.setString(Constants.storageKeyRefreshToken, loginInfo.userToken);
      await _storageService.setString(Constants.storageKeyUserId, loginInfo.userInfo.userId.toString());
      await _storageService.setString(Constants.storageKeyUsername, loginInfo.userInfo.username ?? '');
      await _storageService.setString(Constants.storageKeyLastLoginTime, DateTime.now().toIso8601String());
      
      // 保存完整的原生登录信息（用于后续可能需要的数据）
      await _storageService.setObject('native_login_info', loginInfo.toJson());
      
      // 保存用户资料
      await _saveUserProfileToStorage(userProfile);
      
      debugPrint('✅ 原生登录信息保存完成');
    } catch (e) {
      debugPrint('❌ 保存原生登录信息失败: $e');
      rethrow;
    }
  }
  
  /// ⚠️ 已废弃 - Android原生项目不需要
  /// 
  /// Android原生登录接口（loginNative）已返回完整用户信息
  /// 不需要再次调用API获取用户信息
  /// 
  /// @deprecated 此方法仅用于若依框架登录，Android原生项目已不使用
  /*
  Future<void> _fetchAndSaveUserProfile(TokenModel tokenModel) async {
    try {
      final userProfile = await UserApi.getUserProfile();
      debugPrint('✅ 获取到完整用户信息: ${userProfile.nickName}');
      
      _currentUserProfile.value = userProfile;
      await _saveUserProfileToStorage(userProfile);
      
    } catch (e) {
      debugPrint('⚠️ 获取用户详细信息异常，继续使用基础信息: $e');
    }
  }
  */
  
  /// 保存用户信息到存储
  Future<void> _saveUserProfileToStorage(UserProfileModel userProfile) async {
    final userProfileData = {
      ...userProfile.toJson(),
      'loginTime': DateTime.now().toIso8601String(),
    };
    
    await _storageService.setString(Constants.storageKeyUserId, userProfile.userId.toString());
    await _storageService.setString(Constants.storageKeyUsername, userProfile.userName ?? '');
    await _storageService.setObject(Constants.storageKeyUserInfo, userProfileData);
  }
  
  /// 更新令牌
  Future<void> _updateTokens(TokenModel newTokenModel) async {
    _userToken.value = newTokenModel.accessToken;
    _refreshToken.value = newTokenModel.refreshToken;
    
    await _storageService.setString(Constants.storageKeyUserToken, newTokenModel.accessToken);
    await _storageService.setString(Constants.storageKeyRefreshToken, newTokenModel.refreshToken);
    await _storageService.setObject(Constants.storageKeyTokenModel, newTokenModel.toJson());
    
    debugPrint('✅ 令牌更新成功');
  }
  
  /// 清除所有存储数据
  Future<void> _clearAllStorageData() async {
    final keys = [
      Constants.storageKeyUserToken,
      Constants.storageKeyRefreshToken,
      Constants.storageKeyTokenModel,
      Constants.storageKeyUserId,
      Constants.storageKeyUsername,
      Constants.storageKeyUserInfo,
      Constants.storageKeyLastLoginTime,
    ];
    
    for (final key in keys) {
      await _storageService.remove(key);
    }
    
    debugPrint('✅ 所有存储数据清除成功');
  }
  
}
